home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Bank smakow / BankSmakow.air / BankSmakow.swf / scripts / mx / effects / effectClasses / MaskEffectInstance.as < prev    next >
Text File  |  2009-12-16  |  17KB  |  585 lines
  1. package mx.effects.effectClasses
  2. {
  3.    import flash.display.BitmapData;
  4.    import flash.display.DisplayObject;
  5.    import flash.display.Graphics;
  6.    import flash.display.Shape;
  7.    import flash.events.Event;
  8.    import flash.geom.Matrix;
  9.    import flash.geom.Rectangle;
  10.    import flash.utils.getTimer;
  11.    import mx.controls.SWFLoader;
  12.    import mx.core.Container;
  13.    import mx.core.FlexShape;
  14.    import mx.core.IInvalidating;
  15.    import mx.core.IUIComponent;
  16.    import mx.core.mx_internal;
  17.    import mx.effects.EffectInstance;
  18.    import mx.effects.EffectManager;
  19.    import mx.effects.Tween;
  20.    import mx.events.FlexEvent;
  21.    import mx.events.ResizeEvent;
  22.    import mx.events.TweenEvent;
  23.    
  24.    use namespace mx_internal;
  25.    
  26.    public class MaskEffectInstance extends EffectInstance
  27.    {
  28.       
  29.       mx_internal static const VERSION:String = "3.5.0.12683";
  30.        
  31.       
  32.       private var useSnapshotBounds:Boolean = true;
  33.       
  34.       public var scaleEasingFunction:Function;
  35.       
  36.       public var xTo:Number;
  37.       
  38.       private var _showTarget:Boolean = true;
  39.       
  40.       private var stoppedEarly:Boolean = false;
  41.       
  42.       public var scaleXFrom:Number;
  43.       
  44.       public var scaleYFrom:Number;
  45.       
  46.       protected var effectMask:Shape;
  47.       
  48.       private var _createMaskFunction:Function;
  49.       
  50.       private var moveTween:Tween;
  51.       
  52.       public var scaleYTo:Number;
  53.       
  54.       private var scaleTween:Tween;
  55.       
  56.       public var xFrom:Number;
  57.       
  58.       public var yFrom:Number;
  59.       
  60.       public var targetArea:Rectangle;
  61.       
  62.       protected var targetVisualBounds:Rectangle;
  63.       
  64.       private var invalidateBorder:Boolean = false;
  65.       
  66.       private var origMask:DisplayObject;
  67.       
  68.       private var currentMoveTweenValue:Object;
  69.       
  70.       private var dispatchedStartEvent:Boolean = false;
  71.       
  72.       mx_internal var persistAfterEnd:Boolean = false;
  73.       
  74.       public var moveEasingFunction:Function;
  75.       
  76.       public var yTo:Number;
  77.       
  78.       private var _showExplicitlySet:Boolean = false;
  79.       
  80.       public var scaleXTo:Number;
  81.       
  82.       private var tweenCount:int = 0;
  83.       
  84.       private var origScrollRect:Rectangle;
  85.       
  86.       private var currentScaleTweenValue:Object;
  87.       
  88.       private var effectMaskRefCount:Number = 0;
  89.       
  90.       private var MASK_NAME:String = "_maskEffectMask";
  91.       
  92.       public function MaskEffectInstance(param1:Object)
  93.       {
  94.          super(param1);
  95.       }
  96.       
  97.       override public function get playheadTime() : Number
  98.       {
  99.          var _loc1_:Number = NaN;
  100.          if(moveTween)
  101.          {
  102.             _loc1_ = moveTween.playheadTime;
  103.          }
  104.          else
  105.          {
  106.             if(!scaleTween)
  107.             {
  108.                return 0;
  109.             }
  110.             _loc1_ = scaleTween.playheadTime;
  111.          }
  112.          return _loc1_ + super.playheadTime;
  113.       }
  114.       
  115.       public function set createMaskFunction(param1:Function) : void
  116.       {
  117.          _createMaskFunction = param1;
  118.       }
  119.       
  120.       override public function stop() : void
  121.       {
  122.          stoppedEarly = true;
  123.          super.stop();
  124.          if(moveTween)
  125.          {
  126.             moveTween.stop();
  127.          }
  128.          if(scaleTween)
  129.          {
  130.             scaleTween.stop();
  131.          }
  132.       }
  133.       
  134.       override public function finishEffect() : void
  135.       {
  136.          target.removeEventListener(ResizeEvent.RESIZE,mx_internal::eventHandler);
  137.          if(!mx_internal::persistAfterEnd && !stoppedEarly)
  138.          {
  139.             removeMask();
  140.          }
  141.          super.finishEffect();
  142.       }
  143.       
  144.       private function removeMask() : void
  145.       {
  146.          if(--effectMaskRefCount == 0)
  147.          {
  148.             if(origMask == null || origMask && origMask.name != MASK_NAME)
  149.             {
  150.                target.mask = origMask;
  151.             }
  152.             if(origScrollRect)
  153.             {
  154.                target.scrollRect = origScrollRect;
  155.             }
  156.             if(target is Container)
  157.             {
  158.                target.rawChildren.removeChild(effectMask);
  159.             }
  160.             else
  161.             {
  162.                target.removeChild(effectMask);
  163.             }
  164.             effectMask = null;
  165.          }
  166.       }
  167.       
  168.       private function initMask() : void
  169.       {
  170.          if(!effectMask)
  171.          {
  172.             if(useSnapshotBounds)
  173.             {
  174.                targetVisualBounds = getVisibleBounds(DisplayObject(target));
  175.             }
  176.             else
  177.             {
  178.                targetVisualBounds = new Rectangle(0,0,target.width,target.height);
  179.             }
  180.             effectMask = createMaskFunction(target,targetVisualBounds);
  181.             if(target is Container)
  182.             {
  183.                target.rawChildren.addChild(effectMask);
  184.             }
  185.             else
  186.             {
  187.                target.addChild(effectMask);
  188.             }
  189.             effectMask.name = MASK_NAME;
  190.             effectMaskRefCount = 0;
  191.          }
  192.          effectMask.x = 0;
  193.          effectMask.y = 0;
  194.          effectMask.alpha = 0.3;
  195.          effectMask.visible = false;
  196.          if(effectMaskRefCount++ == 0)
  197.          {
  198.             if(target.mask)
  199.             {
  200.                origMask = target.mask;
  201.             }
  202.             target.mask = effectMask;
  203.             if(target.scrollRect)
  204.             {
  205.                origScrollRect = target.scrollRect;
  206.                target.scrollRect = null;
  207.             }
  208.          }
  209.          invalidateBorder = target is Container && Container(target).border != null && Container(target).border is IInvalidating && DisplayObject(Container(target).border).filters != null;
  210.       }
  211.       
  212.       protected function onMoveTweenUpdate(param1:Object) : void
  213.       {
  214.          saveTweenValue(param1,null);
  215.          if(effectMask)
  216.          {
  217.             effectMask.x = param1[0];
  218.             effectMask.y = param1[1];
  219.          }
  220.          if(invalidateBorder)
  221.          {
  222.             IInvalidating(Container(target).border).invalidateDisplayList();
  223.          }
  224.       }
  225.       
  226.       private function finishTween() : void
  227.       {
  228.          var _loc1_:Array = null;
  229.          var _loc2_:Object = null;
  230.          if(tweenCount == 0 || --tweenCount == 0)
  231.          {
  232.             EffectManager.endVectorEffect(IUIComponent(target));
  233.             _loc1_ = [];
  234.             if(moveTween)
  235.             {
  236.                _loc2_ = moveTween.getCurrentValue(duration);
  237.                _loc1_.push(_loc2_[0]);
  238.                _loc1_.push(_loc2_[1]);
  239.             }
  240.             else
  241.             {
  242.                _loc1_.push(null);
  243.                _loc1_.push(null);
  244.             }
  245.             if(scaleTween)
  246.             {
  247.                _loc2_ = scaleTween.getCurrentValue(duration);
  248.                _loc1_.push(_loc2_[0]);
  249.                _loc1_.push(_loc2_[1]);
  250.             }
  251.             else
  252.             {
  253.                _loc1_.push(null);
  254.                _loc1_.push(null);
  255.             }
  256.             dispatchEvent(new TweenEvent(TweenEvent.TWEEN_END,false,false,_loc1_));
  257.             finishRepeat();
  258.          }
  259.       }
  260.       
  261.       override public function startEffect() : void
  262.       {
  263.          initMask();
  264.          target.addEventListener(ResizeEvent.RESIZE,mx_internal::eventHandler);
  265.          super.startEffect();
  266.       }
  267.       
  268.       public function get createMaskFunction() : Function
  269.       {
  270.          return _createMaskFunction != null ? _createMaskFunction : defaultCreateMask;
  271.       }
  272.       
  273.       protected function defaultCreateMask(param1:Object, param2:Rectangle) : Shape
  274.       {
  275.          var _loc7_:Number = NaN;
  276.          var _loc8_:Number = NaN;
  277.          var _loc9_:Number = NaN;
  278.          var _loc3_:Number = param2.width / Math.abs(param1.scaleX);
  279.          var _loc4_:Number = param2.height / Math.abs(param1.scaleY);
  280.          if(param1 is SWFLoader)
  281.          {
  282.             param1.validateDisplayList();
  283.             if(param1.content)
  284.             {
  285.                _loc3_ = param1.contentWidth;
  286.                _loc4_ = param1.contentHeight;
  287.             }
  288.          }
  289.          var _loc6_:Graphics;
  290.          var _loc5_:Shape;
  291.          (_loc6_ = (_loc5_ = new FlexShape()).graphics).beginFill(16776960);
  292.          _loc6_.drawRect(0,0,_loc3_,_loc4_);
  293.          _loc6_.endFill();
  294.          if(target.rotation == 0)
  295.          {
  296.             _loc5_.width = _loc3_;
  297.             _loc5_.height = _loc4_;
  298.          }
  299.          else
  300.          {
  301.             _loc7_ = param1.rotation * Math.PI / 180;
  302.             _loc8_ = Math.sin(_loc7_);
  303.             _loc9_ = Math.cos(_loc7_);
  304.             _loc5_.width = Math.abs(_loc3_ * _loc9_ - _loc4_ * _loc8_);
  305.             _loc5_.height = Math.abs(_loc3_ * _loc8_ + _loc4_ * _loc9_);
  306.          }
  307.          return _loc5_;
  308.       }
  309.       
  310.       private function saveTweenValue(param1:Object, param2:Object) : void
  311.       {
  312.          var _loc3_:Array = null;
  313.          if(param1 != null)
  314.          {
  315.             currentMoveTweenValue = param1;
  316.          }
  317.          else if(param2 != null)
  318.          {
  319.             currentScaleTweenValue = param2;
  320.          }
  321.          if((moveTween == null || currentMoveTweenValue != null) && (scaleTween == null || currentScaleTweenValue != null))
  322.          {
  323.             _loc3_ = [];
  324.             if(currentMoveTweenValue)
  325.             {
  326.                _loc3_.push(currentMoveTweenValue[0]);
  327.                _loc3_.push(currentMoveTweenValue[1]);
  328.             }
  329.             else
  330.             {
  331.                _loc3_.push(null);
  332.                _loc3_.push(null);
  333.             }
  334.             if(currentScaleTweenValue)
  335.             {
  336.                _loc3_.push(currentScaleTweenValue[0]);
  337.                _loc3_.push(currentScaleTweenValue[1]);
  338.             }
  339.             else
  340.             {
  341.                _loc3_.push(null);
  342.                _loc3_.push(null);
  343.             }
  344.             if(!dispatchedStartEvent)
  345.             {
  346.                dispatchEvent(new TweenEvent(TweenEvent.TWEEN_START));
  347.                dispatchedStartEvent = true;
  348.             }
  349.             dispatchEvent(new TweenEvent(TweenEvent.TWEEN_UPDATE,false,false,_loc3_));
  350.             currentMoveTweenValue = null;
  351.             currentScaleTweenValue = null;
  352.          }
  353.       }
  354.       
  355.       override mx_internal function set playReversed(param1:Boolean) : void
  356.       {
  357.          if(moveTween)
  358.          {
  359.             moveTween.playReversed = param1;
  360.          }
  361.          if(scaleTween)
  362.          {
  363.             scaleTween.playReversed = param1;
  364.          }
  365.          super.playReversed = param1;
  366.       }
  367.       
  368.       override public function play() : void
  369.       {
  370.          super.play();
  371.          initMaskEffect();
  372.          EffectManager.startVectorEffect(IUIComponent(target));
  373.          if(!isNaN(xFrom) && !isNaN(yFrom) && !isNaN(xTo) && !isNaN(yTo))
  374.          {
  375.             ++tweenCount;
  376.             moveTween = new Tween(this,[xFrom,yFrom],[xTo,yTo],duration,-1,onMoveTweenUpdate,onMoveTweenEnd);
  377.             moveTween.playReversed = mx_internal::playReversed;
  378.             if(moveEasingFunction != null)
  379.             {
  380.                moveTween.easingFunction = moveEasingFunction;
  381.             }
  382.          }
  383.          if(!isNaN(scaleXFrom) && !isNaN(scaleYFrom) && !isNaN(scaleXTo) && !isNaN(scaleYTo))
  384.          {
  385.             ++tweenCount;
  386.             scaleTween = new Tween(this,[scaleXFrom,scaleYFrom],[scaleXTo,scaleYTo],duration,-1,onScaleTweenUpdate,onScaleTweenEnd);
  387.             scaleTween.playReversed = mx_internal::playReversed;
  388.             if(scaleEasingFunction != null)
  389.             {
  390.                scaleTween.easingFunction = scaleEasingFunction;
  391.             }
  392.          }
  393.          dispatchedStartEvent = false;
  394.          if(moveTween)
  395.          {
  396.             onMoveTweenUpdate(moveTween.getCurrentValue(0));
  397.          }
  398.          if(scaleTween)
  399.          {
  400.             onScaleTweenUpdate(scaleTween.getCurrentValue(0));
  401.          }
  402.       }
  403.       
  404.       override public function resume() : void
  405.       {
  406.          super.resume();
  407.          if(moveTween)
  408.          {
  409.             moveTween.resume();
  410.          }
  411.          if(scaleTween)
  412.          {
  413.             scaleTween.resume();
  414.          }
  415.       }
  416.       
  417.       private function getVisibleBounds(param1:DisplayObject) : Rectangle
  418.       {
  419.          var _loc2_:BitmapData = new BitmapData(param1.width + 200,param1.height + 200,true,0);
  420.          var _loc3_:Matrix = new Matrix();
  421.          _loc3_.translate(100,100);
  422.          _loc2_.draw(param1,_loc3_);
  423.          var _loc4_:Rectangle = _loc2_.getColorBoundsRect(4278190080,0,false);
  424.          _loc4_.x -= 100;
  425.          _loc4_.y -= 100;
  426.          _loc2_.dispose();
  427.          if(_loc4_.width < param1.width)
  428.          {
  429.             _loc4_.width = param1.width;
  430.             _loc4_.x = 0;
  431.          }
  432.          if(_loc4_.height < param1.height)
  433.          {
  434.             _loc4_.height = param1.height;
  435.             _loc4_.y = 0;
  436.          }
  437.          return _loc4_;
  438.       }
  439.       
  440.       override public function initEffect(param1:Event) : void
  441.       {
  442.          super.initEffect(param1);
  443.          switch(param1.type)
  444.          {
  445.             case "childrenCreationComplete":
  446.             case FlexEvent.CREATION_COMPLETE:
  447.             case FlexEvent.SHOW:
  448.             case Event.ADDED:
  449.             case "resizeEnd":
  450.                showTarget = true;
  451.                break;
  452.             case FlexEvent.HIDE:
  453.             case Event.REMOVED:
  454.             case "resizeStart":
  455.                showTarget = false;
  456.                break;
  457.             case Event.RESIZE:
  458.                useSnapshotBounds = false;
  459.          }
  460.       }
  461.       
  462.       public function set showTarget(param1:Boolean) : void
  463.       {
  464.          _showTarget = param1;
  465.          _showExplicitlySet = true;
  466.       }
  467.       
  468.       protected function onScaleTweenEnd(param1:Object) : void
  469.       {
  470.          onScaleTweenUpdate(param1);
  471.          finishTween();
  472.       }
  473.       
  474.       override mx_internal function eventHandler(param1:Event) : void
  475.       {
  476.          var _loc2_:Tween = null;
  477.          var _loc3_:Number = NaN;
  478.          super.eventHandler(param1);
  479.          if(param1.type == ResizeEvent.RESIZE)
  480.          {
  481.             _loc2_ = moveTween;
  482.             if(!_loc2_ && scaleTween)
  483.             {
  484.                _loc2_ = scaleTween;
  485.             }
  486.             if(_loc2_)
  487.             {
  488.                _loc3_ = getTimer() - _loc2_.startTime;
  489.                if(moveTween)
  490.                {
  491.                   Tween.removeTween(moveTween);
  492.                }
  493.                if(scaleTween)
  494.                {
  495.                   Tween.removeTween(scaleTween);
  496.                }
  497.                tweenCount = 0;
  498.                removeMask();
  499.                initMask();
  500.                play();
  501.                if(moveTween)
  502.                {
  503.                   moveTween.startTime -= _loc3_;
  504.                   moveTween.doInterval();
  505.                }
  506.                if(scaleTween)
  507.                {
  508.                   scaleTween.startTime -= _loc3_;
  509.                   scaleTween.doInterval();
  510.                }
  511.             }
  512.          }
  513.       }
  514.       
  515.       protected function onMoveTweenEnd(param1:Object) : void
  516.       {
  517.          onMoveTweenUpdate(param1);
  518.          finishTween();
  519.       }
  520.       
  521.       override public function reverse() : void
  522.       {
  523.          super.reverse();
  524.          if(moveTween)
  525.          {
  526.             moveTween.reverse();
  527.          }
  528.          if(scaleTween)
  529.          {
  530.             scaleTween.reverse();
  531.          }
  532.          super.playReversed = !mx_internal::playReversed;
  533.       }
  534.       
  535.       override public function end() : void
  536.       {
  537.          stopRepeat = true;
  538.          if(moveTween)
  539.          {
  540.             moveTween.endTween();
  541.          }
  542.          if(scaleTween)
  543.          {
  544.             scaleTween.endTween();
  545.          }
  546.       }
  547.       
  548.       protected function initMaskEffect() : void
  549.       {
  550.          if(!_showExplicitlySet && propertyChanges && propertyChanges.start["visible"] !== undefined)
  551.          {
  552.             _showTarget = !propertyChanges.start["visible"];
  553.          }
  554.       }
  555.       
  556.       protected function onScaleTweenUpdate(param1:Object) : void
  557.       {
  558.          saveTweenValue(null,param1);
  559.          if(effectMask)
  560.          {
  561.             effectMask.scaleX = param1[0];
  562.             effectMask.scaleY = param1[1];
  563.          }
  564.       }
  565.       
  566.       public function get showTarget() : Boolean
  567.       {
  568.          return _showTarget;
  569.       }
  570.       
  571.       override public function pause() : void
  572.       {
  573.          super.pause();
  574.          if(moveTween)
  575.          {
  576.             moveTween.pause();
  577.          }
  578.          if(scaleTween)
  579.          {
  580.             scaleTween.pause();
  581.          }
  582.       }
  583.    }
  584. }
  585.